home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / lib-old / Para.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  10KB  |  376 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. Int = type(0)
  5.  
  6. class Para:
  7.     
  8.     def __init__(self):
  9.         self.words = []
  10.         self.just = 'l'
  11.         self.indent_left = self.indent_right = self.indent_hang = 0
  12.         self.left = None
  13.         self.top = None
  14.         self.right = None
  15.         self.bottom = None
  16.         self.width = None
  17.         self.height = None
  18.         self.lines = None
  19.  
  20.     
  21.     def addword(self, d, font, text, space, stretch):
  22.         if font is not None:
  23.             d.setfont(font)
  24.         
  25.         width = d.textwidth(text)
  26.         ascent = d.baseline()
  27.         descent = d.lineheight() - ascent
  28.         spw = d.textwidth(' ')
  29.         space = space * spw
  30.         stretch = stretch * spw
  31.         tuple = (font, text, width, space, stretch, ascent, descent)
  32.         self.words.append(tuple)
  33.  
  34.     
  35.     def bgn_anchor(self, id):
  36.         self.words.append(id)
  37.  
  38.     
  39.     def end_anchor(self, id):
  40.         self.words.append(0)
  41.  
  42.     
  43.     def getlength(self):
  44.         total = 0
  45.         for word in self.words:
  46.             if type(word) is not Int:
  47.                 total = total + word[2] + word[3]
  48.                 continue
  49.         
  50.         return total
  51.  
  52.     
  53.     def tabto(self, tab):
  54.         total = 0
  55.         (as, de) = (1, 0)
  56.         for i in range(len(self.words)):
  57.             word = self.words[i]
  58.             if type(word) is Int:
  59.                 continue
  60.             
  61.             (fo, te, wi, sp, st, as, de) = word
  62.             self.words[i] = (fo, te, wi, sp, 0, as, de)
  63.             total = total + wi + sp
  64.         
  65.         if total < tab:
  66.             self.words.append((None, '', 0, tab - total, 0, as, de))
  67.         
  68.  
  69.     
  70.     def makehangingtag(self, hang):
  71.         self.tabto(hang)
  72.         self.indent_left = self.indent_left + hang
  73.         self.indent_hang = -hang
  74.  
  75.     
  76.     def layout(self, linewidth):
  77.         self.width = linewidth
  78.         height = 0
  79.         self.lines = lines = []
  80.         avail1 = self.width - self.indent_left - self.indent_right
  81.         avail = avail1 - self.indent_hang
  82.         words = self.words
  83.         i = 0
  84.         n = len(words)
  85.         lastfont = None
  86.         while i < n:
  87.             firstfont = lastfont
  88.             charcount = 0
  89.             width = 0
  90.             stretch = 0
  91.             ascent = 0
  92.             descent = 0
  93.             lsp = 0
  94.             j = i
  95.             while i < n:
  96.                 word = words[i]
  97.                 if type(word) is Int:
  98.                     if word > 0 and width >= avail:
  99.                         break
  100.                     
  101.                     i = i + 1
  102.                     continue
  103.                 
  104.                 (fo, te, wi, sp, st, as, de) = word
  105.                 if width + wi > avail and width > 0 and wi > 0:
  106.                     break
  107.                 
  108.                 if fo is not None:
  109.                     lastfont = fo
  110.                     if width == 0:
  111.                         firstfont = fo
  112.                     
  113.                 
  114.                 charcount = charcount + len(te) + (sp > 0)
  115.                 width = width + wi + sp
  116.                 lsp = sp
  117.                 stretch = stretch + st
  118.                 lst = st
  119.                 ascent = max(ascent, as)
  120.                 descent = max(descent, de)
  121.                 i = i + 1
  122.             while i > j and type(words[i - 1]) is Int and words[i - 1] > 0:
  123.                 i = i - 1
  124.             width = width - lsp
  125.             if i < n:
  126.                 stretch = stretch - lst
  127.             else:
  128.                 stretch = 0
  129.             tuple = (i - j, firstfont, charcount, width, stretch, ascent, descent)
  130.             lines.append(tuple)
  131.             height = height + ascent + descent
  132.             avail = avail1
  133.         self.height = height
  134.  
  135.     
  136.     def visit(self, wordfunc, anchorfunc):
  137.         avail1 = self.width - self.indent_left - self.indent_right
  138.         avail = avail1 - self.indent_hang
  139.         v = self.top
  140.         i = 0
  141.         for tuple in self.lines:
  142.             (wordcount, firstfont, charcount, width, stretch, ascent, descent) = tuple
  143.             h = self.left + self.indent_left
  144.             if i == 0:
  145.                 h = h + self.indent_hang
  146.             
  147.             extra = 0
  148.             if self.just == 'r':
  149.                 h = h + avail - width
  150.             elif self.just == 'c':
  151.                 h = h + (avail - width) / 2
  152.             elif self.just == 'lr' and stretch > 0:
  153.                 extra = avail - width
  154.             
  155.             v2 = v + ascent + descent
  156.             for j in range(i, i + wordcount):
  157.                 word = self.words[j]
  158.                 if type(word) is Int:
  159.                     ok = anchorfunc(self, tuple, word, h, v)
  160.                     if ok is not None:
  161.                         return ok
  162.                         continue
  163.                     continue
  164.                 
  165.                 (fo, te, wi, sp, st, as, de) = word
  166.                 if extra > 0 and stretch > 0:
  167.                     ex = extra * st / stretch
  168.                     extra = extra - ex
  169.                     stretch = stretch - st
  170.                 else:
  171.                     ex = 0
  172.                 h2 = h + wi + sp + ex
  173.                 ok = wordfunc(self, tuple, word, h, v, h2, v2, j == i, j == i + wordcount - 1)
  174.                 if ok is not None:
  175.                     return ok
  176.                 
  177.                 h = h2
  178.             
  179.             v = v2
  180.             i = i + wordcount
  181.             avail = avail1
  182.         
  183.  
  184.     
  185.     def render(self, d, left, top, right):
  186.         if self.width != right - left:
  187.             self.layout(right - left)
  188.         
  189.         self.left = left
  190.         self.top = top
  191.         self.right = right
  192.         self.bottom = self.top + self.height
  193.         self.anchorid = 0
  194.         
  195.         try:
  196.             self.d = d
  197.             self.visit(self.__class__._renderword, self.__class__._renderanchor)
  198.         finally:
  199.             self.d = None
  200.  
  201.         return self.bottom
  202.  
  203.     
  204.     def _renderword(self, tuple, word, h, v, h2, v2, isfirst, islast):
  205.         if word[0] is not None:
  206.             self.d.setfont(word[0])
  207.         
  208.         baseline = v + tuple[5]
  209.         self.d.text((h, baseline - word[5]), word[1])
  210.         if self.anchorid > 0:
  211.             self.d.line((h, baseline + 2), (h2, baseline + 2))
  212.         
  213.  
  214.     
  215.     def _renderanchor(self, tuple, word, h, v):
  216.         self.anchorid = word
  217.  
  218.     
  219.     def hitcheck(self, mouseh, mousev):
  220.         self.mouseh = mouseh
  221.         self.mousev = mousev
  222.         self.anchorid = 0
  223.         self.hits = []
  224.         self.visit(self.__class__._hitcheckword, self.__class__._hitcheckanchor)
  225.         return self.hits
  226.  
  227.     
  228.     def _hitcheckword(self, tuple, word, h, v, h2, v2, isfirst, islast):
  229.         if self.anchorid > 0:
  230.             pass
  231.  
  232.     
  233.     def _hitcheckanchor(self, tuple, word, h, v):
  234.         self.anchorid = word
  235.  
  236.     
  237.     def hasanchor(self, id):
  238.         if not id in self.words:
  239.             pass
  240.         return -id in self.words
  241.  
  242.     
  243.     def extract(self):
  244.         text = ''
  245.         for w in self.words:
  246.             if type(w) is not Int:
  247.                 word = w[1]
  248.                 if w[3]:
  249.                     word = word + ' '
  250.                 
  251.                 text = text + word
  252.                 continue
  253.         
  254.         return text + '\n'
  255.  
  256.     
  257.     def whereis(self, d, mouseh, mousev):
  258.         if mousev < self.top or mousev > self.bottom:
  259.             return None
  260.         
  261.         self.mouseh = mouseh
  262.         self.mousev = mousev
  263.         self.lastfont = None
  264.         self.charcount = 0
  265.         
  266.         try:
  267.             self.d = d
  268.             return self.visit(self.__class__._whereisword, self.__class__._whereisanchor)
  269.         finally:
  270.             self.d = None
  271.  
  272.  
  273.     
  274.     def _whereisword(self, tuple, word, h1, v1, h2, v2, isfirst, islast):
  275.         (fo, te, wi, sp, st, as, de) = word
  276.         if fo is not None:
  277.             self.lastfont = fo
  278.         
  279.         h = h1
  280.         if isfirst:
  281.             h1 = 0
  282.         
  283.         if islast:
  284.             h2 = 999999
  285.         
  286.         if self.lastfont is not None:
  287.             self.d.setfont(self.lastfont)
  288.         
  289.         cc = 0
  290.         for c in te:
  291.             cw = self.d.textwidth(c)
  292.             if self.mouseh <= h + cw / 2:
  293.                 return self.charcount + cc
  294.             
  295.             cc = cc + 1
  296.             h = h + cw
  297.         
  298.         self.charcount = self.charcount + cc
  299.         if self.mouseh <= (h + h2) / 2:
  300.             return self.charcount
  301.         else:
  302.             return self.charcount + 1
  303.  
  304.     
  305.     def _whereisanchor(self, tuple, word, h, v):
  306.         pass
  307.  
  308.     
  309.     def screenpos(self, d, pos):
  310.         if pos < 0:
  311.             (ascent, descent) = self.lines[0][5:7]
  312.             return (self.left, self.top, self.top + ascent, self.top + ascent + descent)
  313.         
  314.         self.pos = pos
  315.         self.lastfont = None
  316.         
  317.         try:
  318.             self.d = d
  319.             ok = self.visit(self.__class__._screenposword, self.__class__._screenposanchor)
  320.         finally:
  321.             self.d = None
  322.  
  323.         if ok is None:
  324.             (ascent, descent) = self.lines[-1][5:7]
  325.             ok = (self.right, self.bottom - ascent - descent, self.bottom - descent, self.bottom)
  326.         
  327.         return ok
  328.  
  329.     
  330.     def _screenposword(self, tuple, word, h1, v1, h2, v2, isfirst, islast):
  331.         (fo, te, wi, sp, st, as, de) = word
  332.         if fo is not None:
  333.             self.lastfont = fo
  334.         
  335.         cc = len(te) + (sp > 0)
  336.         if self.pos > cc:
  337.             self.pos = self.pos - cc
  338.             return None
  339.         
  340.         if self.pos < cc:
  341.             self.d.setfont(self.lastfont)
  342.             h = h1 + self.d.textwidth(te[:self.pos])
  343.         else:
  344.             h = h2
  345.         (ascent, descent) = tuple[5:7]
  346.         return (h, v1, v1 + ascent, v2)
  347.  
  348.     
  349.     def _screenposanchor(self, tuple, word, h, v):
  350.         pass
  351.  
  352.     
  353.     def invert(self, d, pos1, pos2):
  354.         if pos1 is None:
  355.             pos1 = (self.left, self.top, self.top, self.top)
  356.         else:
  357.             pos1 = self.screenpos(d, pos1)
  358.         if pos2 is None:
  359.             pos2 = (self.right, self.bottom, self.bottom, self.bottom)
  360.         else:
  361.             pos2 = self.screenpos(d, pos2)
  362.         (h1, top1, baseline1, bottom1) = pos1
  363.         (h2, top2, baseline2, bottom2) = pos2
  364.         if bottom1 <= top2:
  365.             d.invert((h1, top1), (self.right, bottom1))
  366.             h1 = self.left
  367.             if bottom1 < top2:
  368.                 d.invert((h1, bottom1), (self.right, top2))
  369.             
  370.             top1 = top2
  371.             bottom1 = bottom2
  372.         
  373.         d.invert((h1, top1), (h2, bottom2))
  374.  
  375.  
  376.